Languguage OS 2/Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO/gnu/uucp-doc.lha/uucp-doc-1.04/uucp.info-2

GNU Info File | 1993-02-14 | 51KB | 973 lines

This is Info file uucp.info, produced by Makeinfo-1.49 from the input
file uucp.texi.
   This file documents Taylor UUCP, version 1.04.
   Copyright (C) 1992, 1993 Ian Lance Taylor
   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled "Copying" are included exactly as in the
original, and provided that the entire resulting derived work is
distributed under the terms of a permission notice identical to this
   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled "Copying" may be included in
a translation approved by the author instead of in the original English.
File: uucp.info,  Node: Leaf Example,  Next: Gateway Example,  Prev: config File Examples,  Up: Configuration Examples
Leaf Example
------------
   A relatively common simple case is a "leaf site", a system which
only calls or is called by a single remote site.  Here is a typical
`sys' file that might be used in such a case.  For full details on what
commands can appear in the `sys' file, see *Note sys File::.
   This is the `sys' file that is used at `airs.com'.  We use a single
modem to dial out to `uunet'.  This example shows how you can specify
the port and dialer information directly in the `sys' file for simple
cases.  It also shows the use of the following:
`call-login'
     Using `call-login' and `call-password' allows the default login
     chat script to be used.  In this case, the login name is specified
     in the call-out login file (*note Configuration File Names::.).
`call-timegrade'
     `uunet' is requested to not send us news during the daytime.
`chat-fail'
     If the modem returns `BUSY' or `NO CARRIER' the call is
     immediately aborted.
`protocol-parameter'
     Since `uunet' tends to be slow, the default timeout has been
     increased.
   This `sys' file relies on certain defaults.  It will allow `uunet'
to queue up `rmail' and `rnews' commands.  It will allow users to
request files from `uunet' into the UUCP public directory.  It will
also `uunet' to request files from the UUCP public directory; in fact
`uunet' never requests files, but for additional security we could add
the line `request false'.
     # The following information is for uunet
     system uunet

     # The login name and password are kept in the callout password file
     call-login *
     call-password *

     # We can send anything at any time.
     time any

     # During the day we only accept grade `Z' or above; at other times
     # (not mentioned here) we accept all grades.  uunet queues up news
     # at grade `d', which is lower than `Z'.
     call-timegrade Z Wk0755-2305,Su1655-2305

     # The phone number.
     phone [phone]

     # uunet tends to be slow, so we increase the timeout
     chat-timeout 120

     # We are using a preconfigured Telebit 2500.
     port type modem
     port device /dev/ttyd0
     port baud 19200
     port carrier true
     port dialer chat "" ATZ\r\d\c OK ATDT\D CONNECT
     port dialer chat-fail BUSY
     port dialer chat-fail NO\sCARRIER
     port dialer complete \d\d+++\d\dATH\r\c
     port dialer abort \d\d+++\d\dATH\r\c

     # Increase the timeout and the number of retries.
     protocol-parameter g timeout 20
     protocol-parameter g retries 10
File: uucp.info,  Node: Gateway Example,  Prev: Leaf Example,  Up: Configuration Examples
Gateway Example
---------------
   Many organizations have several local machines which are connected by
UUCP, and a single machine which connects to the outside world.  This
single machine is often referred to as a "gateway" machine.
   For this example I will assume a fairly simple case.  It should still
provide a good general example.  There are three machines, `elmer',
`comton' and `bugs'.  `elmer' is the gateway machine for which I will
show the configuration file.  `elmer' calls out to `uupsi'.  As an
additional complication, `uupsi' knows `elmer' as `airs'; this will
show how a machine can have one name on an internal network but a
different name to the external world. `elmer' has two modems.  It also
has an TCP/IP connection to `uupsi', but since that is supposed to be
reserved for interactive work (it is, perhaps, only a 9600 baud SLIP
line) it will only use it if the modems are not available.
   A network this small would normally use a single `sys' file.
However, for pedagogical purposes I will show two separate `sys' files,
one for the local systems and one for `uupsi'.  This is done with the
`sysfile' command in the `config' file.  Here is the `config' file.
     # This is config
     # The local sys file
     sysfile /usr/local/lib/uucp/sys.local
     # The remote sys file
     sysfile /usr/local/lib/uucp/sys.remote
   Using the defaults feature of the `sys' file can greatly simplify
the listing of local systems.  Here is `sys.local'.  Note that this
assumes that the local systems are trusted; they are permited to request
any world readable file and to write files into any world writable
directory.
     # This is sys.local
     # Get the login name and password to use from the call-out file
     call-login *
     call-password *

     # The systems must use a particular login
     called-login Ulocal

     # Permit sending any world readable file
     local-send /
     remote-send /

     # Permit requesting into any world writable directory
     local-receive /
     remote-receive /

     # Call at any time
     time any

     # Use port1, then port2
     port port1

     alternate

     port port2

     # Now define the systems themselves.  Because of all the defaults we
     # used, there is very little to specify for the systems themselves.

     system comton
     phone [phone]

     system bugs
     phone [phone]
   The `sys.remote' file describes the `uupsi' connection.  The
`myname' command is used to change the UUCP name to `airs' when talking
to `uupsi'.
     # This is sys.remote
     # Define uupsi
     system uupsi

     # The login name and password are in the call-out file
     call-login *
     call-password *

     # We can call out at any time
     time any

     # uupsi uses a special login name
     called-login Uuupsi

     # uuspi thinks of us as `airs'
     myname airs

     # The phone number
     phone [phone]

     # We use port2 first, then port1, then TCP

     port port2

     alternate

     port port1

     alternate

     # We don't bother to make a special entry in the port file for TCP, we
     # just describe the entire port right here.  We use a special chat
     # script over TCP because the usual one confuses some TCP servers.
     port type TCP
     address uu.psi.com
     chat ogin: \L word: \P
   The ports are defined in the file `port' (*note port File::.).  For
this example they are both connected to the same type of 2400 baud
Hayes-compatible modem.
     # This is port

     port port1
     type modem
     device /dev/ttyd0
     dialer hayes
     speed 2400

     port port2
     type modem
     device /dev/ttyd1
     dialer hayes
     speed 2400
   Dialers are described in the `dial' file (*note dial File::.).
     # This is dial

     dialer hayes

     # The chat script used to dial the phone.  \D is the phone number.
     chat "" ATZ\r\d\c OK ATDT\D CONNECT

     # If we get BUSY or NO CARRIER we abort the dial immediately
     chat-fail BUSY
     chat-fail NO\sCARRIER

     # When the call is over we make sure we hangup the modem.
     complete \d\d+++\d\dATH\r\c
     abort \d\d+++\d\dATH\r\c
File: uucp.info,  Node: Time Strings,  Next: Chat Scripts,  Prev: Configuration Examples,  Up: Configuration Files
Time Strings
============
   Several commands use time strings to specify a range of times.  This
section describes how to write time strings.
   A time string may be a list of simple time strings separated with a
vertical bar `|' or a comma `,'.
   Each simple time string must begin with `Su', `Mo', `Tu', `We',
`Th', `Fr', or `Sa', or `Wk' for any weekday, or `Any' for any day.
   Following the day may be a range of hours separated with a hyphen
using 24 hour time.  The range of hours may cross 0; for example
`2300-0700' means any time except 7 AM to 11 PM.  If no time is given,
calls may be made at any time on the specified day(s).
   The time string may also consist of the single word `Never', which
does not match any time, or a single word with a name defined in a
previous `timetable' command (*note Miscellaneous (config)::.).
   Here are a few sample time strings with an explanation of what they
mean.
`Wk2305-0855,Sa,Su2305-1655'
     This means weekdays before 8:55 AM or after 11:05 PM, any time
     Saturday, or Sunday before 4:55 PM or after 11:05 PM.  These are
     approximately the times during which night rates apply to phone
     calls in the U.S.A.  Note that this time string uses, for example,
     `2305' rather than `2300'; this will ensure a cheap rate phone
     call even if the computer clock is running up to five minutes
     ahead of the real time.
`Wk0905-2255,Su1705-2255'
     This means weekdays from 9:05 AM to 10:55 PM, or Sunday from 5:05
     PM to 10:55 PM.  This is approximately the opposite of the
     previous example.
`Any'
     This means any day.  Since no time is specified, it means any time
     on any day.
File: uucp.info,  Node: Chat Scripts,  Next: config File,  Prev: Time Strings,  Up: Configuration Files
Chat Scripts
============
   Chat scripts are used in several different places, such as dialing
out on modems or logging in to remote systems.  Chat scripts are made
up of pairs of strings.  The program waits until it sees the first
string, known as the "expect" string, and then sends out the second
string, the "send" string.
   Each chat script is defined using a set of commands.  These commands
always end in a string beginning with `chat', but may start with
different strings.  For example, in the `sys' file there is one set of
commands beginning with `chat' and another set beginning with
`called-chat'.  The prefixes are only used to disambiguate different
types of chat scripts, and this section ignores the prefixes when
describing the commands.
`chat STRINGS'
     Specify a chat script.  The arguments to the `chat' command are
     pairs of strings separated by whitespace.  The first string of
     each pair is an expect string, the second is a send string.  The
     program will wait for the expect string to appear; when it does,
     the program will send the send string.  If the expect string does
     not appear within a certain number of seconds (as set by the
     `chat-timeout' command) the chat script fails and, typically, the
     call is aborted.  If the final expect string is seen (and the
     optional final send string has been sent), the chat script is
     successful.
     An expect string may contain additional subsend and subexpect
     strings, separated by hyphens.  If the expect string is not seen,
     the subsend string is sent and the chat script continues by
     waiting for the subexpect string.  This means that a hyphen may
     not appear in an expect string; on an ASCII system, use `\055'
     instead.
     An expect string may simply be `""', meaning to skip the expect
     phase.  Otherwise, the following escape characters may appear in
     expect strings:
    `\b'
          a backspace character
    `\n'
          a newline or line feed character
    `\N'
          a null character (for HDB compatibility)
    `\r'
          a carriage return character
    `\s'
          a space character
    `\t'
          a tab character
    `\\'
          a backslash character
    `\DDD'
          character DDD, where DDD are up to three octal digits
    `\xDDD'
          character DDD, where DDD are hexadecimal digits.
     As in C, there may be up to three octal digits following a
     backslash, but the hexadecimal escape sequence continues as far as
     possible.  To follow a hexadecimal escape sequence with a hex
     digit, interpose a send string of `""'.
     A send string may simply be `""' to skip the send phase.
     Otherwise, all of the escape characters legal for expect strings
     may be used, and the following escape characters are also
     permitted:
    `EOT'
          send an end of transmission character (`^D')
    `BREAK'
          send a break character (may not work on all systems)
    `\c'
          suppress trailing carriage return at end of send string
    `\d'
          delay sending for 1 or 2 seconds
    `\e'
          disable echo checking
    `\E'
          enable echo checking
    `\K'
          same as `BREAK' (for HDB compatibility)
    `\p'
          pause sending for a fraction of a second
     Some specific types of chat scripts also define additional escape
     sequences that may appear in the send string.  For example, the
     login chat script defines `\L' and `\P' to send the login name and
     password, respectively.
     A carriage return will be sent at the end of each send string,
     unless the `\c' escape sequence appears in the string.  Note that
     some UUCP packages use `\b' for break, but here it means backspace.
     Echo checking means that after writing each character the program
     will wait until the character is echoed.  Echo checking must be
     turned on separately for each send string for which it is desired;
     it will be turned on for characters following `\E' and turned off
     for characters following `\e'.
`chat-timeout NUMBER'
     The number of seconds to wait for an expect string in the chat
     script before timing out and sending the next subsend or failing
     the chat script entirely.  The default value is 10 for a login
     chat or 60 for any other type of chat.
`chat-fail STRING'
     If the STRING is seen at any time during a chat script, the chat
     script is aborted.  The string may not contain any whitespace
     characters; escape sequences must be used for them.  Multiple
     `chat-fail' commands may appear in a single chat script.  The
     default is to have none.
     This permits a chat script to be quickly aborted if an error
     string is seen.  For example, a script used to dial out on a modem
     might use the command `chat-fail BUSY' to stop the chat script
     immediately if the string `BUSY' was seen.
`chat-seven-bit BOOLEAN'
     If the argument is true, all incoming characters are stripped to
     seven bits when being compared to the expect string.  Otherwise
     all eight bits are used in the comparison.  The default is true,
     because some Unix systems generate parity bits during the login
     prompt which must be ignored while running a chat script.  This
     has no effect on any `chat-program', which must ignore parity by
     itself if necessary.
`chat-program STRINGS'
     Specify a program to run before executing the chat script.  This
     program could run its own version of a chat script, or it could do
     whatever it wants.  If both `chat-program' and `chat' are
     specified, the program is executed first followed by the chat
     script.
     The first argument to the `chat-program' command is the program
     name to run.  The remaining arguments are passed to the program.
     The following escape sequences are recognized in the arguments:
    `\Y'
          port device name
    `\S'
          port speed
    `\\'
          backslash
     Some specific uses of `chat-program' define additional escape
     sequences.
     Arguments other than escape sequences are passed exactly as they
     appear in the configuration file, except that sequences of
     whitespace are compressed to a single space character (this
     exception may be removed in the future).
     If the `chat-program' command is not used, no program is run.
     On Unix, the standard input and standard output of the program
     will be attached to the port in use.  Anything the program writes
     to standard error will be written to the UUCP log file.  No other
     file descriptors will be open.  If the program does not exit with
     a status of 0, it will be assumed to have failed; this means that
     the dialing programs used by some versions of HDB may not be used
     directly, although of course a shell script could be used as an
     interface.
     The program will be run as the `uucp' user, and the environment
     will be that of the process that started `uucico', so care must be
     taken to maintain security.
     No search path is used to find the program; a full path name must
     be given.  If the program is an executable shell script, it will
     be passed to `/bin/sh' even on systems which are unable to execute
     shell scripts.  It is also easy to invoke `/bin/sh' directly.
   Here is a simple example of a chat script that might be used to
reset a Hayes compatible modem.
     chat "" ATZ OK-ATZ-OK
   The first expect string is `""', so it is ignored.  The chat script
then sends `ATZ'.  If the modem responds with `OK', the chat script
finishes.  If 60 seconds (the default timeout) pass before seeing `OK',
the chat script sends another `ATZ'.  If it then sees `OK', the chat
script succeeds.  Otherwise, the chat script fails.
   For a more complex chat script example, see *Note Logging In::.
File: uucp.info,  Node: config File,  Next: sys File,  Prev: Chat Scripts,  Up: Configuration Files
The Main Configuration File
===========================
   The main configuration file is named `config'.
   Since all the values that may be specified in the main configuration
file also have defaults, there need not be a main configuration file at
* Menu:
* Miscellaneous (config)::      Miscellaneous config file commands
* Configuration File Names::    Using different configuration files
* Log File Names::              Using different log files
* Debugging Levels::            Debugging levels
File: uucp.info,  Node: Miscellaneous (config),  Next: Configuration File Names,  Prev: config File,  Up: config File
Miscellaneous config File Commands
----------------------------------
`nodename STRING'
`hostname STRING'
`uuname STRING'
     These keywords are equivalent.  They specify the UUCP name of the
     local host.  If there is no configuration file, an appropriate
     system function will be used to get the host name, if possible.
`spool STRING'
     Specify the spool directory.  The default is from `policy.h'.  This
     is where UUCP files are queued.  Status files and various sorts of
     temporary files are also stored in this directory and
     subdirectories of it.
`pubdir STRING'
     Specify the public directory.  The default is from `policy.h'.
     When a file is named using a leading `~/', it is taken from or to
     the public directory.  Each system may use a separate public
     directory by using the `pubdir' command in the system
     configuration file; see *Note Miscellaneous (sys)::.
`lockdir STRING'
     Specify the directory to place lock files in.  The default is from
     `policy.h'; see the information in that file.  Normally the lock
     directory should be set correctly in `policy.h', and not changed
     here.  However, changing the lock directory is sometimes useful for
     testing purposes.
`unknown STRING ...'
     The STRING and subsequent arguments are treated as though they
     appeared in the system file (*note sys File::.).  They are used to
     apply to any unknown systems that may call in, probably to set
     file transfer permissions and the like.  If the `unknown' command
     is not used, unknown systems are not permitted to call in.
`max-uuxqts NUMBER'
     Specify the maximum number of `uuxqt' processes which may run at
     the same time.  Having several `uuxqt' processes running at once
     can significantly slow down a system, but since `uuxqt' is
     automatically started by `uucico', it can happen quite easily.  The
     default for `max-uuxqts' is 0, which means that there is no limit.
     If HDB configuration files are being read and the code was compiled
     without `HAVE_TAYLOR_CONFIG', then if the file `Maxuuxqts' in the
     configuration directory contains a readable number it will be used
     as the value for `max-uuxqts'.
`timetable STRING STRING'
     The `timetable' defines a timetable that may be used in
     subsequently appearing time strings; *Note Time Strings::.  The
     first string names the timetable entry; the second is a time
     string.
     The following `timetable' commands are predefined.  The NonPeak
     timetable is included for compatibility.  It originally described
     the offpeak hours of Tymnet and Telenet, but both have since
     changed their schedules.
          timetable Evening Wk1705-0755,Sa,Su
          timetable Night Wk2305-0755,Sa,Su2305-1655
          timetable NonPeak Wk1805-0655,Sa,Su
     If this command does not appear, then obviously no additional
     timetables will be defined.
`v2-files BOOLEAN'
     If the code was compiled to be able to read V2 configuration
     files, a false argument to this command will prevent them from
     being read. This can be useful while testing.  The default is true.
`hdb-files BOOLEAN'
     If the code was compiled to be able to read HDB configuration
     files, a false argument to this command will prevent them from
     being read. This can be useful while testing.  The default is true.
File: uucp.info,  Node: Configuration File Names,  Next: Log File Names,  Prev: Miscellaneous (config),  Up: config File
Configuration File Names
------------------------
`sysfile STRINGS'
     Specify the system file(s).  The default is the file `sys' in the
     directory NEWCONFIGDIR.  These files hold information about other
     systems with which this system communicates; see *Note sys File::.
     Multiple system files may be given on the line, and the `sysfile'
     command may be repeated; each system file has its own set of
     defaults.
`portfile STRINGS'
     Specify the port file(s).  The default is the file `port' in the
     directory NEWCONFIGDIR.  These files describe ports which are used
     to call other systems and accept calls from other systems; see
     *Note port File::.  No port files need be named at all.  Multiple
     port files may be given on the line, and the `portfile' command
     may be repeated.
`dialfile STRINGS'
     Specify the dial file(s).  The default is the file `dial' in the
     directory NEWCONFIGDIR.  These files describe dialing devices
     (modems); *Note dial File::.  No dial files need be named at all.
     Multiple dial files may be given on the line, and the `dialfile'
     command may be repeated.
`dialcodefile STRINGS'
     Specify the dialcode file(s).  The default is the file `dialcode'
     in the directory NEWCONFIGDIR.  These files specify dialcodes that
     may be used when sending phone numbers to a modem.  This permits
     using the same set of phone numbers in different area-codes or
     with different phone systems, by using dialcodes to specify the
     calling sequence.  When a phone number goes through dialcode
     translation, the leading alphabetic characters are stripped off.
     The dialcode files are read line by line, just like any other
     configuration file, and when a line is found whose first word is
     the same as the leading characters from the phone number, the
     second word on the line (which would normally consist of numbers)
     replaces the dialcode in the phone number.  No dialcode file need
     be used.  Multiple dialcode files may be specified on the line,
     and the `dialcodefile' command may be repeated; all the dialcode
     files will be read in turn until a dialcode is located.
`callfile STRINGS'
     Specify the call out login name and password file(s).  The default
     is the file `call' in the directory NEWCONFIGDIR.  If the call out
     login name or password for a system are given as `*' (*note
     Logging In::.), these files are read to get the real login name or
     password.  Each line in the file(s) has three words: the system
     name, the login name, and the password.  This file is only used
     when placing calls to remote systems; the password file described
     under `passwdfile' below is used for incoming calls.  The
     intention of the call out file is to permit the system file to be
     publically readable; the call out files must obviously be kept
     secure.  These files need not be used.  Multiple call out files
     may be specified on the line, and the `callfile' command may be
     repeated; all the files will be read in turn until the system is
     found.
`passwdfile STRINGS'
     Specify the password file(s) to use for login names when `uucico'
     is doing its own login prompting, which it does when given the
     `-e', `-l' or `-w' switches.  The default is the file `passwd' in
     the directory NEWCONFIGDIR.  Each line in the file(s) has two
     words: the login name and the password (e.g. `Ufoo foopas').  The
     login name is accepted before the system name is known, so these
     are independent of which system is calling in; a particular login
     may be required for a system by using the `called-login' command
     in the system file (*note Accepting a Call::.).  These password
     files are optional, although one must exist if `uucico' is to
     present its own login prompts.  Multiple password files may be
     specified on the line, and the `passwdfile' command may be
     repeated; all the files will be read in turn until the login name
     is found.
File: uucp.info,  Node: Log File Names,  Next: Debugging Levels,  Prev: Configuration File Names,  Up: config File
Log File Names
--------------
`logfile STRING'
     Name the log file.  The default is from `policy.h'.  Logging
     information is written to this file.  If `HAVE_HDB_LOGGING' is
     defined in `conf.h', then by default a separate log file is used
     for each system.  Using this command to name a log file will cause
     all the systems to use it.
`statfile STRING'
     Name the statistics file.  The default is from `policy.h'.
     Statistical information about file transfers is written to this
     file.
`debugfile STRING'
     Name the file to which debugging information is written.  The
     default is from `policy.h'.  This command is only effective if the
     code has been compiled to include debugging (this is controlled by
     the `DEBUG' variable in `policy.h').  After the first debugging
     message has been written, messages written to the log file are also
     written to the debugging file to make it easier to keep the order
     of actions straight.  The debugging file is different from the log
     file because information such as passwords can appear in it, so it
     must be not be publically readable.
File: uucp.info,  Node: Debugging Levels,  Prev: Log File Names,  Up: config File
Debugging Levels
----------------
`debug STRING ...'
     Set the debugging level.  This command is only effective if the
     code has been compiled to include debugging.  The default is to
     have no debugging.  The arguments are strings which name the types
     of debugging to be turned on.  The following types of debugging
     are defined:
    `abnormal'
          Output debugging messages for abnormal situations, such as
          recoverable errors.
    `chat'
          Output debugging messages for chat scripts.
    `handshake'
          Output debugging messages for the initial handshake.
    `uucp-proto'
          Output debugging messages for the UUCP session protocol.
    `proto'
          Output debugging messages for the individual link protocols.
    `port'
          Output debugging messages for actions on the communication
          port.
    `config'
          Output debugging messages while reading the configuration
          files.
    `spooldir'
          Output debugging messages for actions in the spool directory.
    `execute'
          Output debugging messages whenever another program is
          executed.
    `incoming'
          List all incoming data in the debugging file.
    `outgoing'
          List all outgoing data in the debugging file.
    `all'
          All of the above.
     The debugging level may also be specified as a number.  A 1 will
     set `chat' debugging, a 2 will set both `chat' and `handshake'
     debugging, and so on down the possibilities.  Currently an 11 will
     turn on all possible debugging, since there are 11 types of
     debugging messages listed above; more debugging types may be added
     in the future.  The `debug' command may be used several times in
     the configuration file; every debugging type named will be turned
     on.  When running any of the programs, the `-x' switch (actually,
     for `uulog' it's the `-X' switch) may be used to turn on
     debugging.  The argument to the `-x' switch is one of the strings
     listed above, or a number as described above, or a comma separated
     list of strings (e.g.  `-x chat,handshake').  The `-x' switch may
     also appear several times on the command line, in which case all
     named debugging types will be turned on.  The `-x' debugging is in
     addition to any debugging specified by the `debug' command; there
     is no way to cancel debugging information.  The debugging level
     may also be set specifically for calls to or from a specific
     system with the `debug' command in the system file (*note
     Miscellaneous (sys)::.).
     The debugging messages are somewhat idiosyncratic; it may be
     necessary to refer to the source code for additional information
     in some cases.
File: uucp.info,  Node: sys File,  Next: port File,  Prev: config File,  Up: Configuration Files
The System Configuration File
=============================
   By default there is a single system configuration, named `sys' in
the directory NEWCONFIGDIR.  This may be overridden by the `sysfile'
command in the main configuration file; see *Note Configuration File
Names::.
   These files describe all remote systems known to the UUCP package.
* Menu:
* Defaults and Alternates::     Using defaults and alternates
* Naming the System::           Naming the system
* Calling Out::                 Calling out
* Accepting a Call::            Accepting a call
* Protocol Selection::          Protocol selection
* File Transfer Control::       File transfer control
* Miscellaneous (sys)::         Miscellaneous sys file commands
* Default sys File Values::     Default values
File: uucp.info,  Node: Defaults and Alternates,  Next: Naming the System,  Prev: sys File,  Up: sys File
Defaults and Alternates
-----------------------
   The first set of commands in the file, up to the first `system'
command, specify defaults to be used for all systems in that file.  Each
system file uses a different set of defaults.
   Subsequently, each set of commands from `system' up to the next
`system' command describe a particular system.  Default values may be
overridden for specific systems.
   Each system may then have a series of alternate choices to use when
calling out or calling in.  The first set of commands for a particular
system, up to the first `alternate' command, provide the first choice.
Subsequently, each set of commands from `alternate' up to the next
`alternate' command describe an alternate choice for calling out or
calling in.
   When a system is called, the commands before the first `alternate'
are used to select a phone number, port, and so forth; if the call fails
for some reason, the commands between the first `alternate' and the
second are used, and so forth.  Well, not quite.  Actually, each
succeeding alternate will only be used if it is different in some
relevant way (different phone number, different chat script, etc.).  If
you want to force the same alternate to be used again (to retry a phone
call more than once, for example), enter the phone number (or any other
relevant field) again to make it appear different.
   The alternates can also be used to give different permissions to an
incoming call based on the login name.  This will only be done if the
first set of commands, before the first `alternate' command, uses the
`called-login' command.  The list of alternates will be searched, and
the first alternate with a matching `called-login' command will be
used.  If no alternates match, the call will be rejected.
   The `alternate' command may also be used in the file-wide defaults
(the set of commands before the first `system' command).  This might be
used to specify a list of ports which are available for all systems
(for an example of this, see *Note Gateway Example::) or to specify
permissions based on the login name used by the remote system when it
calls in.  The first alternate for each system will default to the
first alternate for the file-wide defaults (as modified by the commands
used before the first `alternate' command for this system), the second
alternate for each system to the second alternate for the file-wide
defaults (as modified the same way), and so forth.  If a system
specifies more alternates than the file-wide defaults, the trailing
ones will default to the last file-wide default alternate.  If a system
specifies fewer alternates than the file-wide defaults, the trailing
file-wide default alternates will be used unmodified.  The
`default-alternates' command may be used to modify this behaviour.
   This can all get rather confusing, although it's easier to use than
to describe concisely; the `uuchk' program may be used to ensure that
you are getting what you want.
File: uucp.info,  Node: Naming the System,  Next: Calling Out,  Prev: Defaults and Alternates,  Up: sys File
Naming the System
-----------------
`system STRING'
     Specify the remote system name.  Subsequent commands up to the next
     `system' command refer to this system.
`alternate [STRING]'
     Start an alternate set of commands (*note Defaults and
     Alternates::.). An optional argument may be used to name the
     alternate.  This name will be put in the log file if the alternate
     is used to call the system. There is no way to name the first
     alternate (the commands before the first `alternate' command).
`default-alternates BOOLEAN'
     If the argument is false, any remaining default alternates (from
     the defaults specified at the top of the current system file) will
     not be used.  The default is true.
`alias STRING'
     Specify an alias for the current system.  The alias may be used by
     local `uucp' and `uux' commands, as well as by the remote system
     (which can be convenient if a remote system changes its name).  The
     default is to have no aliases.
`myname STRING'
     Specifies a different system name to use when calling the remote
     system. Also, if `called-login' is used and is not `ANY', then,
     when a system logs in with that login name, STRING is used as the
     system name.  Because the local system name must be determined
     before the remote system has identified itself, using `myname' and
     `called-login' together for any system will set the local name for
     that login; this means that each locally used system name must
     have a unique login name associated with it.  This allows a system
     to have different names for an external and an internal network.
     The default is to not use a special local name.
File: uucp.info,  Node: Calling Out,  Next: Accepting a Call,  Prev: Naming the System,  Up: sys File
Calling Out
-----------
   This section describes commands used when placing a call to another
system.
* Menu:
* When to Call::                When to call
* Placing the Call::            Placing the call
* Logging In::                  Logging in
File: uucp.info,  Node: When to Call,  Next: Placing the Call,  Prev: Calling Out,  Up: Calling Out
When to Call
............
`time STRING [NUMBER]'
     Specify when the system may be called.  The first argument is a
     time string; see *Note Time Strings::.  The optional second
     argument specifies a retry time in minutes.  If a call made during
     a time that matches the time string fails, no more calls are
     permitted until the retry time has passed.  By default an
     exponentially increasing retry time is used: after each failure
     the next retry period is longer.  A retry time specified in the
     `time' command is always a fixed amount of time.
     The `time' command may appear multiple times in a single alternate,
     in which case if any time string matches the system may be called.
      When the `time' command is used for a particular system, any
     `time' or `timegrade' commands that appeared in the system
     defaults are ignored.
     The default time string is `Never'.
`timegrade CHARACTER STRING [NUMBER]'
     The CHARACTER specifies a grade.  It must be a single letter or
     digit.  The STRING is a time string (*note Time Strings::.).  All
     jobs of grade CHARACTER or higher (where `0' > `9' > `A' > `Z' >
     `a' > `z') may be run at the specified time. An ordinary `time'
     command is equivalent to using `timegrade' with a grade of `z',
     permitting all jobs.  If there are no jobs of a sufficiently high
     grade according to the time string, the system will not be called.
      Giving the `-s' switch to `uucico' to force it to call a system
     causes it to assume there is a job of grade `0' waiting to be run.
     The optional third argument specifies a retry time in minutes.
     See the `time' command, above, for more details.
     Note that the `timegrade' command serves two purposes: 1) if there
     is no job of sufficiently high grade the system will not be
     called, and 2) if the system is called anyway (because the `-s'
     switch was given to `uucico') only jobs of sufficiently high grade
     will be transferred.  However, if the other system calls in, the
     `timegrade' commands are ignored, and jobs of any grade may be
     transferred (but see `call-timegrade' below).  Also, the
     `timegrade' command will not prevent the other system from
     transferring any job it chooses, regardless of who placed the call.
     The `timegrade' command may appear multiple times without using
     `alternate'.  When the `timegrade' command is used for a
     particular system, any `time' or `timegrade' commands that
     appeared in the system defaults are ignored.
     If this command does not appear, there are no restrictions on what
     grade of work may be done at what time.
`max-retries NUMBER'
     Gives the maximum number of times this system may be retried.  If
     this many calls to the system fail, it will be called at most once
     a day whatever the retry time is.  The default is 26.
`success-wait NUMBER'
     A retry time, in seconds, which applies after a successful call.
     This can be used to put a limit on how frequently the system is
     called.  For example, an argument of 1800 means that the system
     will not be called more than once every half hour.  The default is
     0, which means that there is no limit.
`call-timegrade CHARACTER STRING'
     The CHARACTER is a single character `A' to `Z', `a' to `z', or `0'
     to `9' and specifies a grade.  The STRING is a time string as
     described under the `time' command.  If a call is placed to the
     other system during a time which matches the time string, the
     remote system will be requested to only run jobs of grade
     CHARACTER or higher.  Unfortunately, there is no way to guarantee
     that the other system will obey the request (this UUCP package
     will, but there are others which will not); moreover job grades
     are historically somewhat arbitrary, so specifying a grade will
     only be meaningful if the other system cooperates in assigning
     grades.  This grade restriction only applies when the other system
     is called, not when the other system calls in.
     The `call-timegrade' command may appear multiple times without
     using `alternate'.  If this command does not appear, or if none of
     the time strings match, the remote system will be allowed to send
     whatever grades of work it chooses.
File: uucp.info,  Node: Placing the Call,  Next: Logging In,  Prev: When to Call,  Up: Calling Out
Placing the Call
................
`baud NUMBER'
`speed NUMBER'
     Specify the speed (the term "baud" is technically incorrect, but
     widely understood) at which to call the system.  This will try all
     available ports with that baud rate until an unlocked port is
     found. The ports are defined in the port file.  If both `baud' and
     `port' commands appear, both are used when selecting a port.  To
     allow calls at more than one baud rate, the `alternate' command
     must be used (*note Defaults and Alternates::.).  If this command
     does not appear, there is no default; the baud rate may be
     specified in the port file, but if it is not then the natural baud
     rate of the port will be used (whatever that means on the system).
      Specifying an explicit baud rate of 0 will request the natural
     baud rate of the port, overriding any default baud rate from the
     defaults at the top of the file.
`port STRING'
     Name a particular port or type of port to use when calling the
     system. The information for this port is obtained from the port
     file.  If this command does not appear, there is no default; a
     port must somehow be specified in order to call out (it may be
     specified implicitly using the `baud' command or explicitly using
     the next version of `port').  There may be many ports with the
     same name; each will be tried in turn until an unlocked one is
     found which matches the desired baud rate.
`port STRING ...'
     If more than one string follows the `port' command, the strings are
     treated as a command that might appear in the port file (*note
     port File::.).  If a port is named (by using a single string
     following `port') these commands are ignored; their purpose is to
     permit defining the port completely in the system file rather than
     always requiring entries in two different files.  In order to call
     out, a port must be specified using some version of the `port'
     command, or by using the `baud' command to select ports from the
     port file.
`phone STRING'
`address STRING'
     Give a phone number to call (when using a modem port) or a remote
     host to contact (when using a TCP or TLI port).  The commands
     `phone' and `address' are equivalent; the duplication is intended
     to provide a mnemonic choice depending on the type of port in use.
     When used with a modem port, an `=' character in the phone number
     means to wait for a secondary dial tone (although only some modems
     support this); a `-' character means to pause while dialing for 1
     second (again, only some modems support this).  If the system has
     more than one phone number, each one must appear in a different
     alternate. The `phone' command must appear in order to call out on
     a modem; there is no default.
     When used with a TCP port, the string names the host to contact.
     It may be a domain name or a numeric Internet address.  If no
     address is specified, the system name is used.
     When used with a TLI port, the string is treated as though it were
     an expect string in a chat script, allowing the use of escape
     characters (*note Chat Scripts::.).  The `dialer-sequence' command
     in the port file may override this address (*note port File::.).
     When used with a port that not a modem or TCP or TLI, this command
     is ignored.
File: uucp.info,  Node: Logging In,  Prev: Placing the Call,  Up: Calling Out
Logging In
..........
`chat STRINGS'
`chat-timeout NUMBER'
`chat-fail STRING'
`chat-seven-bit BOOLEAN'
`chat-program STRINGS'
     These commands describe a chat script to use when logging on to a
     remote system.  Chat scripts are explained in *Note Chat Scripts::.
     Two additional escape sequences may be used in send strings.
    `\L'
          Send the login name, as set by the `call-login' command.
    `\P'
          Send the password, as set by the `call-password' command.
     Three additional escape sequences may be used with the
     `chat-program' command.  These are `\L' and `\P', which become the
     login name and password, respectively, and `\Z', which becomes the
     name of the system of being called.
     The default chat script is:
          chat "" \r\c ogin:-BREAK-ogin:-BREAK-ogin: \L word: \P
     This will send a carriage return (the `\c' suppresses the
     additional trailing carriage return that would otherwise be sent)
     and waits for the string `ogin:' (which would be the last part of
     the `login:' prompt supplied by a Unix system).  If it doesn't see
     `ogin:', it sends a break and waits for `ogin:' again.  If it
     still doesn't see `ogin:', it sends another break and waits for
     `ogin:' again. If it still doesn't see `ogin:', the chat script
     aborts and hangs up the phone.  If it does see `ogin:' at some
     point, it sends the login name (as specified by the `call-login'
     command) followed by a carriage return (since all send strings are
     followed by a carriage return unless `\c' is used) and waits for
     the string `word:' (which would be the last part of the
     `Password:' prompt supplied by a Unix system).  If it sees
     `word:', it sends the password and a carriage return, completing
     the chat script.  The program will then enter the handshake phase
     of the UUCP protocol.
     This chat script will work for most systems, so you will only be
     required to use the `call-login' and `call-password' commands. In
     fact, in the file-wide defaults you could set defaults of
     `call-login *' and `call-password *'; you would then just have to
     make an entry for each system in the call-out login file.
     Some systems seem to flush input after the `login:' prompt, so they
     may need a version of this chat script with a `\d' before the
     `\L'.  When using UUCP over TCP, some servers will not be handle
     the initial carriage return sent by this chat script; in this case
     you may have to specify the simple chat script `ogin: \L word: \P'.
`call-login STRING'
     Specify the login name to send with `\L' in the chat script.  If
     the string is `*' (e.g. `call-login *') the login name will be
     fetched from the call out login name and password file (*note
     Configuration File Names::.).  There is no default.
`call-password STRING'
     Specify the password to send with `\P' in the chat script.  If the
     string is `*' (e.g. `call-password *') the password will be
     fetched from the call-out login name and password file (*note
     Configuration File Names::.).  There is no default.
File: uucp.info,  Node: Accepting a Call,  Next: Protocol Selection,  Prev: Calling Out,  Up: sys File
Accepting a Call
----------------
`called-login STRINGS'
     The first STRING specifies the login name that the system must use
     when calling in.  If it is `ANY' (e.g. `called-login ANY') any
     login name may be used; this is useful to override a file-wide
     default and to indicate that future alternates may have different
     login names. Case is significant.  The default value is `ANY'.
     Different alternates (*note Defaults and Alternates::.) may use
     different `called-login' commands, in which case the login name
     will be used to select which alternate is in effect; this will
     only work if the first alternate (before the first `alternate'
     command) uses the `called-login' command.
     Additional strings may be specified after the login name; they are
     a list of which systems are permitted to use this login name.  If
     this feature is used, then normally the login name will only be
     given in a single `called-login' command.  Only systems which
     appear on the list, or which use an explicit `called-login'
     command, will be permitted to use that login name.  If the same
     login name is used more than once with a list of systems, all the
     lists are concatenated together.  This feature permits you to
     restrict a login name to a particular set of systems without
     requiring you to use the `called-login' command for every single
     system; you can achieve a similar effect by using a different
     system file for each permitted login name with an appropriate
     `called-login' command in the file-wide defaults.
`callback BOOLEAN'
     If BOOLEAN is true, then when the remote system calls `uucico'
     will hang up the connection and prepare to call it back. The
     default is false.
`called-chat STRINGS'
`called-chat-timeout NUMBER'
`called-chat-fail STRING'
`called-chat-seven-bit BOOLEAN'
`called-chat-program STRINGS'
     These commands may be used to define a chat script (*note Chat
     Scripts::.) that is run whenever the local system is called by the
     system being defined.  The chat script defined by the `chat'
     command (*note Logging In::.), on the other hand, is used when the
     remote system is called.  This called chat script might be used to
     set special modem parameters that are appropriate to a particular
     system.  It is run after protocol negotiation is complete, but
     before the protocol has been started.  See *Note Logging In:: for
     additional escape sequence which may be used besides those defined
     for all chat scripts.  There is no default called chat script.  If
     the called chat script fails, the incoming call will be aborted.